type runtime.mspan

137 uses

	runtime (current package)
		arena.go#L239: 	fullList *mspan
		arena.go#L242: 	active *mspan
		arena.go#L382: func (a *userArena) refill() *mspan {
		arena.go#L425: 	*mspan // Must represent a user arena chunk.
		arena.go#L449: func (s *mspan) userArenaNextFree(typ *_type, cap int) unsafe.Pointer {
		arena.go#L539: func userArenaHeapBitsSetSliceType(typ *_type, n int, ptr unsafe.Pointer, s *mspan) {
		arena.go#L553: func userArenaHeapBitsSetType(typ *_type, ptr unsafe.Pointer, s *mspan) {
		arena.go#L600: func (s *mspan) writeUserArenaHeapBits(addr uintptr) (h writeUserArenaHeapBits) {
		arena.go#L620: func (h writeUserArenaHeapBits) write(s *mspan, bits, valid uintptr) writeUserArenaHeapBits {
		arena.go#L651: func (h writeUserArenaHeapBits) pad(s *mspan, size uintptr) writeUserArenaHeapBits {
		arena.go#L665: func (h writeUserArenaHeapBits) flush(s *mspan, addr, size uintptr) {
		arena.go#L737: func newUserArenaChunk() (unsafe.Pointer, *mspan) {
		arena.go#L763: 	var span *mspan
		arena.go#L846: func (s *mspan) isUnusedUserArenaChunk() bool {
		arena.go#L855: func (s *mspan) setUserArenaChunkToFault() {
		arena.go#L936: func freeUserArenaChunk(s *mspan, x unsafe.Pointer) {
		arena.go#L997: func (h *mheap) allocUserArenaChunk() *mspan {
		arena.go#L998: 	var s *mspan
		malloc.go#L969: func nextFreeFast(s *mspan) gclinkptr {
		malloc.go#L996: func (c *mcache) nextFree(spc spanClass) (v gclinkptr, s *mspan, checkGCTrigger bool) {
		malloc.go#L1456: func mallocgcSmallNoscanReuse(c *mcache, span *mspan, spc spanClass, size uintptr, needzero bool) unsafe.Pointer {
		malloc.go#L2044: func (c *mcache) nextReusableNoScan(s *mspan, spc spanClass) (gclinkptr, *mspan) {
		malloc_stubs.go#L512: func nextFreeFastTiny(span *mspan) gclinkptr {
		malloc_stubs.go#L532: func nextFreeFastStub(span *mspan) gclinkptr {
		malloc_stubs.go#L550: func heapSetTypeNoHeaderStub(x, dataSize uintptr, typ *_type, span *mspan) uintptr {
		malloc_stubs.go#L568: func writeHeapBitsSmallStub(span *mspan, x, dataSize uintptr, typ *_type) uintptr {
		malloc_stubs.go#L630: func writeHeapBitsDoubleCheck(span *mspan, x, dataSize, src, src0, i, j, bits uintptr, typ *_type) {
		mbitmap.go#L118: func (span *mspan) typePointersOf(addr, size uintptr) typePointers {
		mbitmap.go#L135: func (span *mspan) typePointersOfUnchecked(addr uintptr) typePointers {
		mbitmap.go#L179: func (span *mspan) typePointersOfType(typ *abi.Type, addr uintptr) typePointers {
		mbitmap.go#L342: func (span *mspan) objBase(addr uintptr) uintptr {
		mbitmap.go#L508: func (s *mspan) initHeapBits() {
		mbitmap.go#L537: func (span *mspan) heapBits() []uintptr {
		mbitmap.go#L585: func (span *mspan) heapBitsSmallForAddr(addr uintptr) uintptr {
		mbitmap.go#L624: func (span *mspan) writeHeapBitsSmall(x, dataSize uintptr, typ *_type) (scanSize uintptr) {
		mbitmap.go#L705: func heapSetTypeNoHeader(x, dataSize uintptr, typ *_type, span *mspan) uintptr {
		mbitmap.go#L716: func heapSetTypeSmallHeader(x, dataSize uintptr, typ *_type, header **_type, span *mspan) uintptr {
		mbitmap.go#L744: func heapSetTypeLarge(x, dataSize uintptr, typ *_type, span *mspan) uintptr {
		mbitmap.go#L802: func doubleCheckHeapType(x, dataSize uintptr, gctyp *_type, header **_type, span *mspan) {
		mbitmap.go#L831: func doubleCheckHeapPointers(x, dataSize uintptr, typ *_type, header **_type, span *mspan) {
		mbitmap.go#L888: func doubleCheckHeapPointersInterior(x, interior, size, dataSize uintptr, typ *_type, header **_type, span *mspan) {
		mbitmap.go#L966: func doubleCheckTypePointersOfType(s *mspan, typ *_type, addr, size uintptr) {
		mbitmap.go#L1086: func (s *mspan) allocBitsForIndex(allocBitIndex uintptr) markBits {
		mbitmap.go#L1095: func (s *mspan) refillAllocCache(whichByte uint16) {
		mbitmap.go#L1113: func (s *mspan) nextFreeIndex() uint16 {
		mbitmap.go#L1172: func (s *mspan) isFree(index uintptr) bool {
		mbitmap.go#L1193: func (s *mspan) isFreeOrNewlyAllocated(index uintptr) bool {
		mbitmap.go#L1209: func (s *mspan) divideByElemSize(n uintptr) uintptr {
		mbitmap.go#L1225: func (s *mspan) objIndex(p uintptr) uintptr {
		mbitmap.go#L1308: func badPointer(s *mspan, p, refBase, refOff uintptr) {
		mbitmap.go#L1361: func findObject(p, refBase, refOff uintptr) (base uintptr, s *mspan, objIndex uintptr) {
		mbitmap.go#L1495: func (s *mspan) countAlloc() int {
		mcache.go#L48: 	alloc [numSpanClasses]*mspan
		mcache.go#L95: var emptymspan mspan
		mcache.go#L242: func (c *mcache) allocLarge(size uintptr, noscan bool) *mspan {
		mcentral.go#L82: func (c *mcentral) cacheSpan() *mspan {
		mcentral.go#L109: 	var s *mspan
		mcentral.go#L205: func (c *mcentral) uncacheSpan(s *mspan) {
		mcentral.go#L251: func (c *mcentral) grow() *mspan {
		mcheckmark.go#L167: 	forEachSpecial(func(p uintptr, s *mspan, sp *special) bool {
		mcheckmark.go#L298: func forEachSpecial(yield func(p uintptr, s *mspan, sp *special) bool) {
		mgcmark.go#L472: func gcScanFinalizer(spf *specialfinalizer, s *mspan, gcw *gcWork) {
		mgcmark.go#L1639: func greyobject(obj, base, off uintptr, span *mspan, gcw *gcWork, objIndex uintptr) {
		mgcmark.go#L1748: func gcmarknewobject(span *mspan, obj uintptr) {
		mgcmark_greenteagc.go#L185: func (s *mspan) initInlineMarkBits() {
		mgcmark_greenteagc.go#L196: func (s *mspan) moveInlineMarks(dst *gcBits) {
		mgcmark_greenteagc.go#L221: func (s *mspan) inlineMarkBits() *spanInlineMarkBits {
		mgcmark_greenteagc.go#L228: func (s *mspan) markBitsForIndex(objIndex uintptr) (bits markBits) {
		mgcmark_greenteagc.go#L239: func (s *mspan) markBitsForBase() markBits {
		mgcmark_greenteagc.go#L248: func (s *mspan) scannedBitsForIndex(objIndex uintptr) markBits {
		mgcsweep.go#L96: func (h *mheap) nextSpanForSweep() *mspan {
		mgcsweep.go#L101: 		var s *mspan
		mgcsweep.go#L337: 	*mspan
		mgcsweep.go#L342: func (l *sweepLocker) tryAcquire(s *mspan) (sweepLocked, bool) {
		mgcsweep.go#L465: func (s *mspan) ensureSwept() {
		mgcsweep.go#L859: func (s *mspan) reportZombies() {
		mgcwork.go#L438: 		var s *mspan
		mheap.go#L86: 	allspans []*mspan // all spans out there
		mheap.go#L282: 	spans [pagesPerArena]*mspan
		mheap.go#L422: type mspan struct {
		mheap.go#L424: 	next *mspan     // next span in list, or nil if none
		mheap.go#L425: 	prev *mspan     // previous span in list, or nil if none
		mheap.go#L518: func (s *mspan) base() uintptr {
		mheap.go#L522: func (s *mspan) layout() (size, n, total uintptr) {
		mheap.go#L546: 	s := (*mspan)(p)
		mheap.go#L555: 		var new []*mspan
		mheap.go#L696: func spanOf(p uintptr) *mspan {
		mheap.go#L731: func spanOfUnchecked(p uintptr) *mspan {
		mheap.go#L742: func spanOfHeap(p uintptr) *mspan {
		mheap.go#L791: 	h.spanalloc.init(unsafe.Sizeof(mspan{}), recordspan, unsafe.Pointer(h), &memstats.mspan_sys)
		mheap.go#L1006: func (h *mheap) alloc(npages uintptr, spanclass spanClass) *mspan {
		mheap.go#L1010: 	var s *mspan
		mheap.go#L1039: func (h *mheap) allocManual(npages uintptr, typ spanAllocType) *mspan {
		mheap.go#L1048: func (h *mheap) setSpans(base, npage uintptr, s *mspan) {
		mheap.go#L1137: func (h *mheap) tryAllocMSpan() *mspan {
		mheap.go#L1160: func (h *mheap) allocMSpanLocked() *mspan {
		mheap.go#L1166: 		return (*mspan)(h.spanalloc.alloc())
		mheap.go#L1172: 			pp.mspancache.buf[i] = (*mspan)(h.spanalloc.alloc())
		mheap.go#L1192: func (h *mheap) freeMSpanLocked(s *mspan) {
		mheap.go#L1224: func (h *mheap) allocSpan(npages uintptr, typ spanAllocType, spanclass spanClass) (s *mspan) {
		mheap.go#L1439: func (h *mheap) initSpan(s *mspan, typ spanAllocType, spanclass spanClass, base, npages, scav uintptr) {
		mheap.go#L1666: func (h *mheap) freeSpan(s *mspan) {
		mheap.go#L1710: func (h *mheap) freeManual(s *mspan, typ spanAllocType) {
		mheap.go#L1730: func (h *mheap) freeSpanLocked(s *mspan, typ spanAllocType) {
		mheap.go#L1819: func (span *mspan) init(base uintptr, npages uintptr) {
		mheap.go#L1842: func (span *mspan) inList() bool {
		mheap.go#L1849: 	first *mspan // first span in list, or nil if none
		mheap.go#L1850: 	last  *mspan // last span in list, or nil if none
		mheap.go#L1859: func (list *mSpanList) remove(span *mspan) {
		mheap.go#L1884: func (list *mSpanList) insert(span *mspan) {
		mheap.go#L1902: func (list *mSpanList) insertBack(span *mspan) {
		mheap.go#L1982: func spanHasSpecials(s *mspan) {
		mheap.go#L1990: func spanHasNoSpecials(s *mspan) {
		mheap.go#L2075: func (span *mspan) specialFindSplicePoint(offset uintptr, kind byte) (**special, bool) {
		mheap.go#L2756: func newSpecialsIter(span *mspan) specialsIter {
		mspanset.go#L83: func (b *spanSet) push(s *mspan) {
		mspanset.go#L150: func (b *spanSet) pop() *mspan {
		mspanset.go#L419: func (p *atomicMSpanPointer) Load() *mspan {
		mspanset.go#L420: 	return (*mspan)(p.p.Load())
		mspanset.go#L424: func (p *atomicMSpanPointer) StoreNoWB(s *mspan) {
		os_nonopenbsd.go#L11: func osStackAlloc(s *mspan) {
		os_nonopenbsd.go#L16: func osStackFree(s *mspan) {
		pinner.go#L290: func (s *mspan) pinnerBitSize() uintptr {
		pinner.go#L297: func (s *mspan) newPinnerBits() *pinnerBits {
		pinner.go#L304: func (s *mspan) getPinnerBits() *pinnerBits {
		pinner.go#L308: func (s *mspan) setPinnerBits(p *pinnerBits) {
		pinner.go#L315: func (s *mspan) refreshPinnerBits() {
		pinner.go#L346: func (span *mspan) incPinCounter(offset uintptr) {
		pinner.go#L367: func (span *mspan) decPinCounter(offset uintptr) bool {
		runtime2.go#L834: 		buf [128]*mspan
		stack.go#L406: 		var s *mspan
		traceallocfree.go#L85: func traceSpanTypeAndClass(s *mspan) traceArg {
		traceallocfree.go#L93: func (tl traceLocker) SpanExists(s *mspan) {
		traceallocfree.go#L98: func (tl traceLocker) SpanAlloc(s *mspan) {
		traceallocfree.go#L103: func (tl traceLocker) SpanFree(s *mspan) {
		traceallocfree.go#L108: func traceSpanID(s *mspan) traceArg {